from NodeTable import NodeTable

class NodeTableWrapper(NodeTable):
    #protected final NodeTable 
    nodeTable = None

    def __init__(self, nodeTable):
        self.nodeTable = nodeTable
    #protected NodeTableWrapper(NodeTable nodeTable):
        #this.nodeTable = nodeTable
    #}

    
    
    # param 
    # result NodeTable
    def wrapped(self):
        return self.nodeTable


    
    
    # param Node
    # result NodeId
    def getAllocateNodeId(self, node):
        return self.nodeTable.getAllocateNodeId(node)


    
    
    # param Node
    # result NodeId
    def getNodeIdForNode(self, node):
        return self.nodeTable.getNodeIdForNode(node)


    
    
    # param NodeId
    # result Node
    def getNodeForNodeId(self, id):
        return self.nodeTable.getNodeForNodeId(id)


    
    
    # param Node
    # result boolean
    def containsNode(self, node):
        return self.nodeTable.containsNode(node)


    
    
    # param NodeId
    # result boolean
    def containsNodeId(self, nodeId):
        return self.nodeTable.containsNodeId(nodeId)


    
    
    # param List<Node> boolean
    # result List<NodeId>  
    def bulkNodeToNodeId(self, nodes, withAllocation):
        return self.nodeTable.bulkNodeToNodeId(nodes, withAllocation)


    
    
    # param List<NodeId>
    # result List<Node> 
    def bulkNodeIdToNode(self, nodeIds):
        return self.nodeTable.bulkNodeIdToNode(nodeIds)


    
    
    # param 
    # result Iterator<Pair<NodeId, Node>>
    def all(self):
        return self.nodeTable.all()


    
    
    # param 
    # result boolean
    def isEmpty(self):
        return self.nodeTable.isEmpty()


    
    
    # param 
    # result void
    def sync(self):
        self.nodeTable.sync()


    
    
    # param 
    # result void
    def close(self):
        self.nodeTable.close()
